I don't have a very strong opinion. But I don't see how it would hurt to keep these const.

Well they have no effect and we also don't have the definition and declaration in sync. In some cases it might even be misleading. It also exposes bugs in our parsing as we are not properly handling this code.

The point is to have const only in the implementation (where it matters), not in the declaration, right? So we don't actually lose anything here, since top-level const has no effect in a function declaration.

it has no effect on the function interface. but it does have an effect in the function body.

The point is to have const only in the implementation (where it matters), not in the declaration, right?

In my opinion it would be a bad idea to have different const-qualifiers in the declaration and definition/implementation. Right?

It has no effect. there's also cases where the header and source were not in sync and nothing will tell you. It actually doesn't matter at all. It just makes things "cleaner" - and exposes Cppcheck bugs :)

It has no effect.

Well.. it does have an effect in the function body.

void foo(const int x) {
    x=3; // <- not allowed because of const
} 

I do not have a strong opinion if we should use const for parameters passed by value. But in my opinion we should not have different constness in the declaration and implementation. If the implementation uses const then I feel the declaration should too.

And as I said.. how does it hurt with const?

there's also cases where the header and source were not in sync and nothing will tell you.

Are you sure that this is explicitly permitted by the language standard? Can it be a compiler bug?

Well.. it does have an effect in the function body.

That wasn't changed.

Are you sure that this is explicitly permitted by the language standard? Can it be a compiler bug?

Yes, it is allowed. No, it is not a bug. That's what this check is about: https://clang.llvm.org/extra/clang-tidy/checks/readability/avoid-const-params-in-decls.html

The following are the same as the top-level const has no effect:

void f(const int);
void f(int);

well.. I guess the language standard permits it then but I see no reference..

imho.. having different const in the declaration and implementation seems weird to me. And nobody seems to disagree.

I don't see how it hurts to have the const. I do find it strange that people intentionally WANT to have different constness in the declaration and implementation.

Long time lurker.

Interesting discussion in this stackoverflow question.

"Dropping const from function prototypes has the advantage that you don't need to alter the header file if you decide to drop const from implementation part later."

and

"It is all a matter of who needs which information. You provide the parameter by value so the caller does not need to know anything on what you do (internally) with it. ... In your implementation you do care that you can promise not to alter ..."